Mechanical machines

Robots and Automatic Machines Were Generally Very Inventive: Al-Jazari (XII Century)

Hesdin Castle (Robert II of Artois), Leonardo’s robot…

Mechanical machines

Jaquet-Droz automata (XVIII century):

Mechanical machines

• But this is in mechanics, in mathematics/logic AI it was quite rudimentary for a long time

Logic machine of Ramon Llull (XIII-XIV centuries)

• Starting with Dr. Frankenstein, further AI in the literature appears constantly …

Shennon’s Theseus

• YouTube Video
• Early 1950s, Claude Shannon (The father of Information Theory) demonstrates Theseus
• A life-sized magnetic mouse controlled by relay circuits, learns its way around a maze.

1956-1960: Great hopes

• Optimistic time. It seemed a that we were almost there…
• Allen Newell, Herbert A. Simon, and Cliff Shaw: Logic Theorist.
• Automated reasoning.
• It was able to prof most of the Principia Mathematica, in some places even more elegant than Russell and Whitehead.

1956-1960: Big Hopes

• General Problem Solver - a program that tried to think as a person
• A lot of programs that have been able to do some limited things (MicroWorlds):
  • Analogy (IQ tests with multiple choice questions)
  • Student (algebraic verbal tasks)
  • Blocks World (rearranged 3D blocks).

1970s: Knowledge Based Systems

• The bottom line: to accumulate a fairly large set of rules and knowledge about the subject area, then draw conclusions.
• First success: MYCIN - Diagnosis of blood infections:
  • about 450 rules
  • The results are like an experienced doctor and significantly better than beginner doctors.

1980-2010: Commercial applications Industry AI

• The first AI department was at Dec (Digital Equipment Corporation). It is argued that by 1986 he saved the Dec about $10 million per year.
• The boom ended by the end of the 80s, when many companies could not live up to high expectations.

DEFINITION

• How to determine “learning”?

• The definition is very (too?) General.
• What specific examples can be given?

Tasks and concepts of ML

Tasks and concepts of ML: Supervised Learning

• training sample – a set of examples, each of which consists of input features (attributes) and the correct “answers” - the response variable
• Learn a rule that maps input features to the response variable
• Then this rule is applied to new examples (deployment)
• The main thing is to train a model that explains not only examples from the training set, but also new examples (generalizes)
• Otherwise - overfitting

Tasks and concepts of ML: unsupervised learning

There are no correct answers, only data, e.g. clustering:

• We need to divide the data into pre -unknown classes to some extent similar:
  • highlight the family of genes from the sequences of nucleotides
  • cluster users and personalize the application for them
  • cluster the mass spectrometric image to parts with different composition

Tasks and concepts of ML: unsupervised learning

• Dimensionality reduction: data have a high dimension, it is necessary to reduce it, select the most informative features so that all of the above algorithms can work
• Matrix Competition: There is a sparse matrix, we must predict what is in the missing positions.
• Anomaly detection: find anomalies in the data, e.g. fraud detection.
• Often the outputs answers are given for a small part of the data, then we call it semi -supervised Learning.

Tasks and concepts of ML: reinforcement learning

• Multi-armed bandits: there is a certain set of actions, each of which leads to random results, you need to get as much rewards possible
• Exploration vs.Exploitation: how and when to proceed from the study of the new to use what has already studied
• Credit Assignment: You get rewarded at the very end (won the game), and we must somehow distribute this reward on all the moves that led to victory.

Tasks and concepts of ML: active learning

• Active Learning - how to choose the following (relatively expensive) test
• Boosting - how to combine several weak classifiers so that it turns out good
• Model Selection - where to draw a line between models with many parameters and with a few.
• Ranking: response list is ordered (internet search)

Tasks and concepts of AI

Tasks and concepts of AI: Reasoning

• Bayesian networks: given conditional probabilities, calculate the probability of the event
• o1 by OpenAI: a family of AI models that are designed to perform complex reasoning tasks, such as math, coding, and science. o1 models placed among the top 500 students in the US in a qualifier for the USA Math Olympiad (AIME)
• Gemini 2.0: model for the agentic era

Tasks and concepts of AI: Representation

• Knowledge Graphs: a graph database that uses semantic relationships to represent knowledge
• Embeddings: a way to represent data in a lower-dimensional space
• Transformers: a deep learning model that uses self-attention to process sequential data

Tasks and concepts of AI: Generation

In shadows of data, uncertainty reigns,
Bayesian whispers, where knowledge remains.
With prior beliefs, we start our quest,
Updating with evidence, we strive for the best.

A dance of the models, predictions unfold,
Inferences drawn, from the new and the old.
Through probabilities, we find our way,
In the world of AI, it’s the Bayesian sway.

So gather your data, let prior thoughts flow,
In the realm of the unknown, let your insights grow.
For in this approach, with each little clue,
We weave understanding, both rich and true.

Music

Tasks and concepts of AI: Generation

from openai import OpenAI
client = OpenAI(api_key="your-api-key")
response = client.images.generate(
    model="dall-e-3",
    prompt="a hockey player trying to understand the Bayes rule",
    size="1024x1024",
    quality="standard",
    n=1,
)

print(response.data[0].url)

Tasks and concepts of AI: Generation

A humorous and illustrative scene of a hockey player sitting on a bench in full gear, holding a hockey stick in one hand and a whiteboard marker in th

Chess and AI

Old AI: Deep Blue (1997) vs. Garry Kasparov

AlphaGo Zero

• Remove all human knowledge from training process - only uses self play,
• Takes raw board as input and neural network predicts the next move.
• Uses Monte Carlo tree search to evaluate the position.
• The algorithm was able to beat AlphaGo 100-0. The algorithm was then used to play chess and shogi and was able to beat the best human players in those games as well.

Alpha GO vs Lee Sedol: Move 37 by AlphaGo in Game Two

Probability in machine learning

• In all methods and approaches, it is useful not only generate an answer, but also evaluate how confident in this answer, how well the model describes the data, how these values will change in further experiments, etc.
• Therefore, the central role in machine learning is played by the theory of probability - and we will also actively use it.

Review of Basic Probability Concepts

Probability lets us talk efficiently about things that we are uncertain about.

• What will Amazon’s sales be next quarter?
• What will the return be on my stocks next year?
• How often will users click on a particular Google ad?

All these involve estimating or predicting unknowns!!

Random Variables

Random Variables are numbers that we are not sure about. There’s a list of potential outcomes. We assign probabilities to each outcome.

Example: Suppose that we are about to toss two coins. Let \(X\) denote the number of heads. We call \(X\) the random variable that stands for the potential outcome.

Probability Distribution

We describe the behavior of random variables with a Probability Distribution

Example: Suppose we are about to toss two coins. Let \(X\) denote the number of heads.

\[X = \left\{ \begin{array}{ll} 0 \text{ with prob. } 1/4\\ 1 \text{ with prob. } 1/2\\ 2 \text{ with prob. } 1/4 \end{array} \right.\]

\(X\) is called a Discrete Random Variable

Question: What is \(P(X=0)\)? How about \(P(X \geq 1)\)?

Example: Happiness Index

“happiness index” as a function of salary.

Is \(P(Y=2 \mid X=3) > P(Y=2)\)?

Bayes Rule

The computation of \(P(x \mid y)\) from \(P(x)\) and \(P(y \mid x)\) is called Bayes theorem: \[ P(x \mid y) = \frac{P(y,x)}{P(y)} = \frac{P(y\mid x)p(x)}{p(y)} \]

This shows now the conditional distribution is related to the joint and marginal distributions.

You’ll be given all the quantities on the r.h.s.

Bayes Rule

Key fact: \(P(x \mid y)\) is generally different from \(P(y \mid x)\)!

Example: Most people would agree

\[\begin{align*} Pr & \left ( Practice \; hard \mid Play \; in \; NBA \right ) \approx 1\\ Pr & \left ( Play \; in \; NBA \mid Practice \; hard \right ) \approx 0 \end{align*}\]

The main reason for the difference is that \(P( Play \; in \; NBA ) \approx 0\).

Independence

Two random variable \(X\) and \(Y\) are independent if \[ P(Y = y \mid X = x) = P (Y = y) \] for all possible \(x\) and \(y\) values. Knowing \(X=x\) tells you nothing about \(Y\)!

Example: Tossing a coin twice. What’s the probability of getting \(H\) in the second toss given we saw a \(T\) in the first one?

Sally Clark Case: Independence or Bayes?

Sally Clark was accused and convicted of killing her two children

They could have both died of SIDS.

• The chance of a family which are non-smokers and over 25 having a SIDS death is around 1 in 8,500.

• The chance of a family which has already had a SIDS death having a second is around 1 in 100.

• The chance of a mother killing her two children is around 1 in 1,000,000.

Random Variables: Expectation \(E(X)\)

The expected value of a random variable is simply a weighted average of the possible values X can assume.

The weights are the probabilities of occurrence of those values.

\[E(X) = \sum_x xP(X=x)\]

With \(n\) equally likely outcomes with values \(x_1, \ldots, x_n\), \(P(X = x_i) = 1/n\)

\[E(X) = \frac{x_1+x_2+\ldots+x_n}{n}\]

Roulette Expectation

• European Odds: 36 numbers (red/black) + zero
• You bet $1 on 11 Black (pays 35 to 1)
• \(X\) is the return on this bet

\[E(X) = \frac{1}{37}\times 36 + \frac{36}{37}\times 0 = 0.97\]

• If you bet $1 on Black (pays 1 to 1)

\[E(X) = \frac{18}{37}\times 2 + \frac{19}{37}\times 0 = 0.97\]

Casino is guaranteed to make money in the long run!

Standard Deviation \(sd(X)\) and Variance \(Var(X)\)

The variance is calculated as

\[Var(X) = E\left((X - E(X))^2\right)\]

A simpler calculation is \(Var(X) = E(X^2) - E(X)^2\).

The standard deviation is the square-root of variance.

\[sd(X) = \sqrt{Var(X)}\]

Roulette Variance

• European Odds: 36 numbers (red/black) + zero
• You bet $1 on 11 Black (pays 35 to 1)
• \(X\) is the return on this bet

\[Var(X) = \frac{1}{37}\times (36 - 0.97)^2 + \frac{36}{37}\times (0 - 0.97)^2 = 34\]

• If you bet $1 on Black (pays 1 to 1)

\[Var(X) = \frac{18}{37}\times (2 - 0.97)^2+ \frac{19}{37}\times (0- 0.97)^2 = 1\]

If your goal is to spend as much time as possible in the casino (free drinks): place small bets on black/red

Example: \(E(X)\) and \(Var(X)\)

Tortoise and Hare are selling cars. Probability distributions, means and variances for \(X\), the number of cars sold

Expectation and Variance Calculations

Let’s do Tortoise expectations and variances

• The Tortoise \[\begin{align*} E(T) &= (1/2)(1) + (1/2)(2) = 1.5 \\ Var(T) &= E(T^2) - E(T)^2 \\ &= (1/2)(1)^2 + (1/2)(2)^2 - (1.5)^2 = 0.25 \end{align*}\]

• Now the Hare’s \[\begin{align*} E(H) &= (1/2)(0) + (1/2)(3) = 1.5 \\ Var(H) &= (1/2)(0)^2 + (1/2)(3)^2- (1.5)^2 = 2.25 \end{align*}\]

Expectation and Variance Interpretation

What do these tell us above the long run behavior?

• Tortoise and Hare have the same expected number of cars sold.
• Tortoise is more predictable than Hare. He has a smaller variance The standard deviations \(\sqrt{Var(X)}\) are \(0.5\) and \(1.5\), respectively
• Given two equal means, you always want to pick the lower variance.

Linear Combinations of Random Variables

Two key properties:

Let \(a, b\) be given constants

• Expectations and Variances \[\begin{align*} E(aX + bY) &= a E(X) + b E(Y) \\ Var(aX + bY) &= a^2 Var(X) + b^2 Var(Y) + 2 ab Cov(X,Y) \end{align*}\]

where \(Cov(X,Y)\) is the covariance between random variables.

Tortoise and Hare Portfolio

What about Tortoise and Hare? We need to know \(Cov(\text{Tortoise, Hare})\). Let’s take \(Cov(T,H) = -1\) and see what happens

Suppose \(a = \frac{1}{2}, b= \frac{1}{2}\) Expectation and Variance

\[\begin{align*} E\left(\frac{1}{2} T + \frac{1}{2} H\right) &= \frac{1}{2} E(T) + \frac{1}{2} E(H) = \frac{1}{2} \times 1.5 + \frac{1}{2} \times 1.5 = 1.5 \\ Var\left(\frac{1}{2} T + \frac{1}{2} H\right) &= \frac{1}{4} 0.25 + \frac{1}{4} 2.25 - 2 \frac{1}{2} \frac{1}{2} = 0.625 - 0.5 = 0.125 \end{align*}\]

Much lower!

“Personalization" \(=\)”Conditional Probability"

• Conditional probability is how AI systems express judgments in a way that reflects their partial knowledge.
• Personalization runs on conditional probabilities, all of which must be estimated from massive data sets in which you are the conditioning event.

Many Business Applications!! Suggestions vs Search….

Medical Diagnostics - Visualization

“Personalization” = “Conditional Probability”

Conditional probability is how AI systems express judgments in a way that reflects their partial knowledge.

Personalization runs on conditional probabilities, all of which must be estimated from massive data sets in which you are the conditioning event.

Many Business Applications!! Suggestions vs Search, ….

How does Netflix Give Recommendations?

Will a subscriber like Saving Private Ryan, given that he or she liked the HBO series Band of Brothers?

Both are epic dramas about the Normandy invasion and its aftermath.

100 people in your database, and every one of them has seen both films.

Their viewing histories come in the form of a big “ratings matrix”.

\[P(\text{likes Saving Private Ryan} \mid \text{likes Band of Brothers})=\frac{56}{56+14}=80\%\]

Netflix - Latent Features

• The User-Film Interaction is calculated based on a person’s ratings of similar films exhibit patterns because those ratings are all associated with a latent feature of that person.
• There’s not just one latent feature to describe Netflix subscribers, but dozens or even hundreds. There’s a “British murder mystery” feature, a “gritty character-driven crime drama” feature, a “cooking show” feature, a “hipster comedy films” feature, …

The Hidden Features Tell the Story

• These latent features are the magic elixir of the digital economy–a special brew of data, algorithms, and human insight that represents the most perfect tool ever conceived for targeted marketing.
• Your precise combination of latent features–your tiny little corner of a giant multidimensional Euclidean space–makes you a demographic of one.
• Netflix spent $130 million for 10 episodes on The Crown. Other network television: $400 million commissioning 113 pilots, of which 13 shows made it to a second season.

Why Distributions Matter

#| include: false
knitr::knit_hooks$set(pars = function(before, options, envir) {
  if (before) {
    par(mar = c(2.5, 2.5, 0.7, 0.5), bty = "n", cex.lab = 0.7, cex.axis = 0.5, cex.main = 0.5, pch = 20, cex = 1, mgp = c(1.5, 0.4, 0))
  }
})
library(tidyverse)
library(broom)
library(knitr)

Binomial Distribution

#| echo: false
#| fig-height: 5
barplot(dbinom(0:20, size = 20, prob = 0.3),
  names.arg = 0:20, col = "steelblue",
  xlab = "Number of Successes", ylab = "Probability",
  main = "Binomial(n=20, p=0.3)")

NFL Patriots Coin Toss

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
# "25 choose 19" = number of ways to pick 19 wins from 25 games
choose(25, 19)

# Probability = (ways to get 19 wins) × (probability of any specific sequence)
choose(25, 19) * 0.5^25

EPL Goals: Mean ≈ Variance

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
goals <- c(epl$home_score, epl$guest_score)
mean(goals)  # Average goals per team per match
var(goals)   # Variance ≈ Mean suggests Poisson!

Goals Follow a Poisson Distribution

#| code-fold: true
#| code-summary: "Show R code"
#| fig-height: 5.5
goals <- c(epl$home_score, epl$guest_score)
lambda <- mean(goals)
x <- 0:8
observed <- table(factor(goals, levels = x)) / length(goals)
expected <- dpois(x, lambda = lambda)

barplot(rbind(observed, expected), beside = TRUE, 
        names.arg = x, col = c("steelblue", "coral"),
        xlab = "Goals Scored", ylab = "Proportion",
        legend.text = c("Observed", "Poisson Model"))

Poisson Distribution

Team-Specific \(\lambda\): Arsenal vs Liverpool

To predict a specific match, we estimate each team’s scoring rate:

• Arsenal’s attack: How many goals do they typically score at home?
• Liverpool’s defense: How many goals do they typically concede away?
• Adjustment: Scale by league average to get relative strength

For Arsenal vs Liverpool at home, we estimate Arsenal will score about 1.8 goals on average. Liverpool’s away \(\lambda\) would be calculated similarly.

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
# Simple estimate: average goals scored and conceded
arsenal_attack <- mean(epl$home_score[epl$home_team_name == "Arsenal"])
liverpool_defense <- mean(epl$home_score[epl$away_team_name == "Liverpool"])
league_avg <- mean(goals)

# Arsenal's expected goals vs Liverpool (simplified)
lambda_arsenal <- arsenal_attack * (liverpool_defense / league_avg)
lambda_arsenal

Monte Carlo Simulation

Once we have \(\lambda\) for each team, we can simulate the match thousands of times.

For Arsenal (\(\lambda=1.8\)) vs Liverpool (\(\lambda=1.5\)), running 10,000 simulations gives:

• Arsenal wins: ~42% of simulations
• Draw: ~24% of simulations
  
• Liverpool wins: ~34% of simulations

This is how betting companies set their odds!

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
set.seed(42)
n_sims <- 10000
# Simulate Arsenal vs Liverpool
arsenal_goals <- rpois(n_sims, lambda = 1.8)  # λ for Arsenal
liverpool_goals <- rpois(n_sims, lambda = 1.5) # λ for Liverpool

# Match outcomes
c(Arsenal_Win = mean(arsenal_goals > liverpool_goals),
  Draw = mean(arsenal_goals == liverpool_goals),
  Liverpool_Win = mean(arsenal_goals < liverpool_goals))

Why Monte Carlo?

Central Limit Theorem (CLT)

CLT in Action: Michigan Election Polls

Suppose the true vote share in Michigan is 51%. What happens when we poll voters?

• Each voter is like a coin flip (vote A or B)
• Small samples are noisy; large samples converge to the truth
• The distribution of poll results becomes Normal

#| fig-height: 4.5
#| code-fold: true
#| code-summary: "Show R code"
#| layout-ncol: 3
set.seed(42)
true_p <- 0.51
# Poll of 10 voters
hist(replicate(1000, mean(rbinom(10, 1, true_p))), breaks = 20,
     main = "Poll: 10 Voters", xlab = "Vote Share", col = "steelblue", 
     freq = FALSE, xlim = c(0.2, 0.8))
abline(v = true_p, col = "red", lwd = 2, lty = 2)
# Poll of 100 voters
hist(replicate(1000, mean(rbinom(100, 1, true_p))), breaks = 20,
     main = "Poll: 100 Voters", xlab = "Vote Share", col = "steelblue", 
     freq = FALSE, xlim = c(0.2, 0.8))
abline(v = true_p, col = "red", lwd = 2, lty = 2)
# Poll of 1000 voters
hist(replicate(1000, mean(rbinom(1000, 1, true_p))), breaks = 20,
     main = "Poll: 1000 Voters", xlab = "Vote Share", col = "steelblue", 
     freq = FALSE, xlim = c(0.2, 0.8))
abline(v = true_p, col = "red", lwd = 2, lty = 2)

Larger samples → tighter Normal distribution around the true value (red line)

Normal Distribution

#| echo: false
#| fig-height: 5
x <- seq(-4, 4, length = 200)
plot(x, dnorm(x), type = "l", lwd = 3, col = "steelblue",
     xlab = "Standard Deviations from Mean", ylab = "Density")
polygon(c(x[x >= -1 & x <= 1], 1, -1), 
        c(dnorm(x[x >= -1 & x <= 1]), 0, 0), col = rgb(0.3, 0.5, 0.7, 0.3))
abline(v = c(-2, -1, 1, 2), lty = 2, col = "gray")
text(0, 0.15, "68%", cex = 1.2)

Normal: Heights of Adults

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
# What proportion are between 67 and 73 inches (+/- 1 sd)?
pnorm(73, mean = 70, sd = 3) - pnorm(67, mean = 70, sd = 3)

# What height is taller than 95% of men?
qnorm(0.95, mean = 70, sd = 3)

The 1987 Stock Market Crash: A 5-Sigma Event

How extreme was the October 1987 crash of -21.76%?

• Prior to crash: \(\mu = 1.2\%\), \(\sigma = 4.3\%\) → Z-score = \(\frac{-21.76 - 1.2}{4.3} = -5.34\)
• Under Normal model: probability = 1 in 20 million (once every 130,000 years!)
• Yet 5+ sigma events happened in 1987, 2008, and 2020

Conclusion: The model is wrong — stock returns have “fat tails.” Banks using Normal-based VaR dramatically underestimate risk.

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
pnorm(-5.34)  # Probability of -5.34 sigma event

Fat Tails: Reality vs Normal Model

What is Regression?

Simple Example: House Prices

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
d <- read.csv("data/SaratogaHouses.csv")
model <- lm(price ~ livingArea, data = d)
coef(model)

Visualizing the Fit

#| echo: false
#| fig-height: 5.5
d$price <- d$price / 1000
d$livingArea <- d$livingArea / 1000
model <- lm(price ~ livingArea, data = d)
plot(d$livingArea, d$price, pch = 21, bg = "lightblue", cex = 0.6,
     xlab = "Living Area (1000 sq ft)", ylab = "Price ($1000)")
abline(model, col = "red", lwd = 3)

Google vs S&P 500 (CAPM)

The Capital Asset Pricing Model (CAPM) asks: Does a stock follow the market or beat it?

\[\text{Google Return} = \alpha + \beta \times \text{Market Return}\]

• \(\beta\) (beta): How volatile is the stock relative to the market?
• \(\alpha\) (alpha): Does the stock outperform after adjusting for risk?

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
#| message: false
library(quantmod)
getSymbols(c("GOOG", "SPY"), from = "2017-01-01", to = "2023-12-31") |> invisible()
goog <- as.numeric(dailyReturn(GOOG))
spy <- as.numeric(dailyReturn(SPY))
model <- lm(goog ~ spy)
print(model)

Google vs S&P 500: CAPM Results

#| echo: false
#| fig-height: 5.5
plot(spy, goog, pch = 20, col = rgb(0.3, 0.5, 0.7, 0.5), cex = 0.8,
     xlab = "S&P 500 Daily Return", ylab = "Google Daily Return",
     main = "Google vs Market (2017-2023)")
abline(model, col = "red", lwd = 3)
abline(h = 0, v = 0, lty = 2, col = "gray")
legend("topleft", legend = bquote(beta == .(round(coef(model)[2], 2))), 
       col = "red", lwd = 3, bty = "n")

Orange Juice: Price & Advertising

How does advertising affect price sensitivity? We model sales as a function of price and whether the product was featured in ads.

Key finding: The interaction term (log(price):feat) is negative and significant — advertising changes how customers respond to price!

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
oj <- read.csv("data/oj.csv")
model <- lm(logmove ~ log(price) * feat, data = oj)
tidy(model) |> select(term, estimate, p.value) |> kable(digits = 3)

From Regression to Classification

#| echo: false
#| fig-height: 5
x <- seq(-6, 6, length = 200)
plot(x, 1/(1 + exp(-x)), type = "l", lwd = 3, col = "steelblue",
     xlab = expression("Linear Predictor (" * beta * "'x)"), ylab = "Probability",
     main = "The Logistic (Sigmoid) Function")
abline(h = 0.5, lty = 2, col = "gray")
abline(h = c(0, 1), lty = 3, col = "red")
text(4, 0.75, "Always between 0 and 1", cex = 0.9)

NBA Point Spread Example

Can Vegas point spreads predict game outcomes? We fit a logistic regression using historical NBA data.

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
NBA <- read.csv("data/NBAspread.csv")
model <- glm(favwin ~ spread - 1, family = binomial, data = NBA)
tidy(model) |> kable(digits = 3)

Interpretation: For each additional point in the spread, log-odds of favorite winning increases by 0.16. The p-value < 0.001 confirms spreads are highly predictive.

Making Predictions

Using our model, we can predict win probability for any point spread:

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
predict(model, newdata = data.frame(spread = c(4, 8)), type = "response")

Same approach used for: credit scoring, churn prediction, marketing response, fraud detection — any binary outcome.

Confusion Matrix

#| echo: true
#| code-fold: true
#| code-summary: "Show R code"
pred <- predict(model, type = "response") > 0.5
table(Actual = NBA$favwin, Predicted = as.integer(pred))

Understanding the Confusion Matrix

Key Metrics:

• Accuracy = (TP + TN) / Total — overall correctness
• Precision = TP / (TP + FP) — “Of predicted wins, how many were right?”
• Recall = TP / (TP + FN) — “Of actual wins, how many did we catch?”

Caution: Accuracy can mislead! A spam filter predicting “not spam” for everything has 99% accuracy but catches zero spam. Choose metrics based on business costs.

ROC Curve: The Trade-off

#| echo: false
#| fig-height: 5.5
pred_prob <- predict(model, type = "response")
roc_data <- data.frame(
  threshold = seq(0, 1, by = 0.01)
) |>
  rowwise() |>
  mutate(
    sensitivity = mean(pred_prob[NBA$favwin == 1] > threshold),
    specificity = mean(pred_prob[NBA$favwin == 0] <= threshold)
  )

plot(1 - roc_data$specificity, roc_data$sensitivity, type = "l", lwd = 3,
     col = "steelblue", xlab = "False Positive Rate", ylab = "True Positive Rate",
     main = "ROC Curve")
abline(0, 1, lty = 2, col = "gray")

Summary

Statistics is the science of decision-making under uncertainty

Supplemental Reading

The Language Challenge

“You shall know a word by the company it keeps.” — J.R. Firth (1957)

Language poses unique challenges for AI:

• Unlike images (continuous pixels) or audio (waveforms), text is discrete symbols
• The word “cat” is not inherently closer to “dog” than to “quantum”
• Yet humans effortlessly recognize semantic similarities

The breakthrough: Represent words as vectors in continuous space where geometry encodes meaning.

From Symbols to Vectors

The Problem with One-Hot Encoding:

Each word gets a unique vector with a single 1:

• “cat” → [0, 0, 1, 0, 0, …, 0]
• “dog” → [0, 1, 0, 0, 0, …, 0]

Problem: Cosine similarity between any two words = 0

No notion of semantic similarity is captured!

Solution: Learn dense vector representations where similar words are close together.

The Twenty Questions Intuition

Imagine playing Twenty Questions to identify words:

Each word becomes a vector of answers. Similar words give similar answers → similar vectors!

This is the essence of word embeddings.

Word2Vec: Learning from Context

The Distributional Hypothesis: Words appearing in similar contexts have similar meanings.

%%| echo: false
%%| fig-width: 12
flowchart LR
    C1["The ___ sat on the mat"]
    C2["The ___ sat on the rug"]
    
    Cat["cat"] --> C1
    Dog["dog"] --> C2
    
    Cat --> V["Similar Vectors!"]
    Dog --> V
    
    style Cat fill:#e1f5fe,stroke:#1976d2
    style Dog fill:#e1f5fe,stroke:#1976d2
    style V fill:#c8e6c9,stroke:#2e7d32

Result: Vector arithmetic captures analogies!

\[\vec{king} - \vec{man} + \vec{woman} \approx \vec{queen}\]

Word2Vec: War and Peace

Training Word2Vec on Tolstoy’s War and Peace reveals thematic structure:

Word2Vec embeddings from War and Peace, reduced to 2D via PCA

War and Peace: Semantic Clusters

The Word2Vec visualization reveals meaningful semantic relationships:

Key observation: “Peace” sits between government and social domains — central to the narrative’s dual structure.

Business applications: Netflix recommendations, Amazon suggestions, LinkedIn job matching, document search

The Skip-Gram Model

Given a center word, predict surrounding context words:

%%| echo: false
%%| fig-width: 10
flowchart LR
    A[loves] --> B[the]
    A --> C[man]
    A --> D[his]
    A --> E[son]
    
    style A fill:#e1f5fe,stroke:#0277bd,stroke-width:2px
    style B fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    style C fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    style D fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    style E fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px

\[P(\text{context} \mid \text{center}) = \prod_{j} P(w_{j} \mid w_{\text{center}})\]

The learned vectors capture semantic relationships because words with similar contexts get similar representations.

From Words to Sentences: The Attention Revolution

The Problem: Static Embeddings

• The word “bank” has one vector, whether it’s “river bank” or “investment bank.”
• This conflation of senses creates an information bottleneck.

The Sequential Bottleneck (RNNs/LSTMs):

• Processed text step-by-step (like reading through a straw).
• Early information “vanished” as sentences grew longer.
• Impossible to parallelize effectively on modern GPUs.

The Breakthrough: Attention Mechanisms

• Let each word dynamically “attend” to all other words simultaneously.
• Example: “The trophy wouldn’t fit in the suitcase because it was too big.”
• Self-attention identifies that “it” refers to “trophy” by looking at the whole sentence at once.

Result: Contextual representations that change based on surrounding words.

Attention: QKV Interaction

%%| echo: false
%%| fig-width: 10
flowchart LR
    k1[k1]
    k2[k2]
    km[km]
    
    Q[Query q] --> a1[score1]
    Q --> a2[score2]
    Q --> am[scorem]
    
    k1 --> a1
    k2 --> a2
    km --> am
    
    a1 -.-> v1[v1]
    a2 -.-> v2[v2]
    am -.-> vm[vm]
    
    v1 --> O[Output]
    v2 --> O
    vm --> O
    
    style Q fill:#e1f5fe,stroke:#0277bd
    style O fill:#c8e6c9,stroke:#2e7d32

\[\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V\]

Attention: A Visual Example

For “The trophy wouldn’t fit in the suitcase because it was too big”:

The model learns that “it” most likely refers to “trophy” by attending strongly to it!

Self-Attention vs Cross-Attention

%%| echo: false
%%| fig-width: 4
flowchart LR
    w1["The"] <--> w2["cat"]
    w2 <--> w3["sat"]
    w1 <--> w3
    
    style w1 fill:#e1f5fe,stroke:#1976d2
    style w2 fill:#e1f5fe,stroke:#1976d2
    style w3 fill:#e1f5fe,stroke:#1976d2

%%| echo: false
%%| fig-width: 4
flowchart LR
    e1["The"]
    e2["cat"]
    d1["Le"]
    d2["chat"]
    
    e1 --> d1
    e2 --> d2
    e1 -.-> d2
    e2 -.-> d1
    
    style e1 fill:#e1f5fe,stroke:#1976d2
    style e2 fill:#e1f5fe,stroke:#1976d2
    style d1 fill:#c8e6c9,stroke:#2e7d32
    style d2 fill:#c8e6c9,stroke:#2e7d32

The Transformer Architecture

%%| echo: false
%%| fig-width: 12
flowchart LR
    In["Input"] --> Tok["Token"] --> Emb["Embed"] --> Att["Attention"] --> FF["FeedForward"] --> Out["Output"]
    
    style In fill:#e3f2fd,stroke:#1976d2
    style Att fill:#fff3e0,stroke:#f57c00
    style FF fill:#e8f5e9,stroke:#388e3c
    style Out fill:#f3e5f5,stroke:#7b1fa2

Key innovations:

• Self-attention replaces recurrence → parallel processing
• Positional encoding preserves word order
• Multi-head attention captures different relationship types
• Feed-forward layers add nonlinear transformations

Why Transformers Won

Transformers scale with compute → the foundation of modern LLMs.

From Transformers to LLMs

The Scale Approach:

%%| echo: false
%%| fig-width: 9
flowchart LR
    G1["GPT-1<br/>117M"] --> G2["GPT-2<br/>1.5B"]
    G2 --> G3["GPT-3<br/>175B"]
    G3 --> G4["GPT-4<br/>~1.8T"]
    
    style G1 fill:#e3f2fd
    style G2 fill:#bbdefb
    style G3 fill:#90caf9
    style G4 fill:#42a5f5

Emergent capabilities appear at scale:

• Chain-of-thought reasoning
• In-context learning (few-shot)
• Code generation
• Multi-step planning

Why We Need Randomness: The Obama Example

Prompt: “The first African American president is Barack…”

• Most probable next token: “Obama” ✓
• Also correct: “Hussein” (his middle name)

A greedy strategy always picks “Obama” — but in formal documents, “Barack Hussein Obama” is preferred.

Temperature > 0 allows the model to explore alternatives that may better fit the context.

The LLM Lifecycle

%%| echo: false
%%| fig-width: 12
flowchart LR
    D[Data Collection] --> P[Pre-Training]
    P --> I[Instruction Tuning]
    I --> A[Alignment]
    A --> Dep[Deployment]
    
    style D fill:#e3f2fd,stroke:#1976d2
    style P fill:#e8f5e9,stroke:#388e3c
    style I fill:#fff3e0,stroke:#f57c00
    style A fill:#fce4ec,stroke:#c2185b
    style Dep fill:#f3e5f5,stroke:#7b1fa2

Alignment: Why It Matters

%%| echo: false
%%| fig-width: 10
flowchart LR
    Q["User Query"]
    
    Q --> U["Unaligned"]
    Q --> A["Aligned"]
    
    U --> UR["Yes, only true god"]
    
    A --> AR["Multiple perspectives exist"]
    
    style Q fill:#e3f2fd,stroke:#1976d2
    style UR fill:#ffcccc,stroke:#cc0000
    style AR fill:#ccffcc,stroke:#00cc00

Example: “Is Allah the only god?”

• Unaligned: “Yes, Allah is the one true god and all other beliefs are false.”
• Aligned: “In Islam, Allah is considered the one God. Other religions have different perspectives. I can provide factual information if helpful.”

This nuanced behavior emerges from alignment training, not pre-training alone.

Context Windows and Prompting

Context window: Maximum tokens the model can “see” at once

%%| echo: false
%%| fig-width: 10
flowchart LR
    S[System Prompt<br/>~500 tokens]
    T[Tools/Schemas<br/>~300 tokens]
    H[History<br/>~1000 tokens]
    R[Retrieved Docs<br/>~2000 tokens]
    U[User Query<br/>~200 tokens]
    
    S --> M[LLM]
    T --> M
    H --> M
    R --> M
    U --> M
    
    style S fill:#e3f2fd
    style R fill:#c8e6c9
    style U fill:#fff3e0

Prompting strategies: Zero-shot, Few-shot, Chain-of-thought, System prompts

What Are AI Agents?

“The question of whether a computer can think is no more interesting than the question of whether a submarine can swim.” — Edsger Dijkstra

AI agents are autonomous systems that:

• Perceive their environment
• Reason about goals
• Take actions to achieve outcomes
• Learn from results

Unlike chatbots, agents can act in the world.

The Agent Loop

%%| echo: false
%%| fig-width: 10
flowchart LR
    P["Perceive"] --> R["Reason"]
    R --> A["Act"]
    A --> O["Observe"]
    O --> P
    
    style P fill:#e3f2fd,stroke:#1976d2
    style R fill:#fff3e0,stroke:#f57c00
    style A fill:#e8f5e9,stroke:#388e3c
    style O fill:#fce4ec,stroke:#c2185b

The agent perceives its environment, reasons about goals, acts to achieve outcomes, observes the result, and repeats — a continuous loop of intelligent behavior.

Tool Use: Giving LLMs Hands

LLMs are “brains without hands” — function calling bridges this gap:

%%| echo: false
%%| fig-width: 10
flowchart LR
    U["Query"] --> L["LLM"]
    L --> TC["Tool Call"]
    TC --> O["Orchestrator"]
    O --> T["Tool"]
    T --> |"Result"| L
    L --> R["Response"]
    
    style U fill:#e3f2fd,stroke:#1976d2
    style L fill:#fff3e0,stroke:#f57c00
    style TC fill:#fce4ec,stroke:#c2185b
    style T fill:#e8f5e9,stroke:#388e3c
    style R fill:#f3e5f5,stroke:#7b1fa2

Examples: Web search, database queries, code execution, API calls.

Example: Currency Conversion Agent

User: “What’s $100 in euros?”

Agent reasoning:

• I need to convert currency
• Call convert_currency(amount=100, from="USD", to="EUR")

Tool returns: 92.50

Agent response: “100 US dollars is approximately 92.50 euros at current exchange rates.”

The agent reasons about what tool to use, then acts to get information.

Multi-Step Planning

Complex tasks require chained actions:

%%| echo: false
%%| fig-width: 12
flowchart LR
    Task[Task] --> get_rates[get_rates]
    get_rates --> Rates[Rates]
    Rates --> get_prices[get_prices]
    get_prices --> Prices[Prices]
    Prices --> correlate[correlate]
    correlate --> r[r=0.73]
    r --> report[report]
    report --> Final[Final Report]
    
    style Task fill:#e3f2fd,stroke:#1976d2
    style get_rates fill:#fff3e0,stroke:#f57c00
    style Rates fill:#fff3e0,stroke:#f57c00
    style get_prices fill:#fff3e0,stroke:#f57c00
    style Prices fill:#fff3e0,stroke:#f57c00
    style correlate fill:#fff3e0,stroke:#f57c00
    style r fill:#fff3e0,stroke:#f57c00
    style report fill:#fff3e0,stroke:#f57c00
    style Final fill:#c8e6c9,stroke:#2e7d32

Each step informs the next — true autonomous problem-solving.

Planning Capabilities

Planning capabilities enable:

Business impact: Agents can handle multi-hour research tasks that would take humans days.

ReAct: The Loop

The Loop:

Key insight: Unlike single-pass generation, ReAct agents can course-correct based on intermediate results.

Case Study: ChatDev

ChatDev orchestrates a virtual software company with specialized AI agents:

%%| echo: false
%%| fig-width: 10
flowchart LR
    CEO[CEO] --- CTO[CTO]
    CTO --- CPO[CPO]
    Prog[Programmer] --- Des[Designer]
    Test[Tester] --- Prog2[Programmer]
    
    CEO --> Prog
    Des --> Test
    Test --> Doc[Documentation]
    
    style CEO fill:#ffcccc,stroke:#cc0000
    style CTO fill:#ccffcc,stroke:#00cc00
    style Prog fill:#cce5ff,stroke:#1976d2
    style Test fill:#fff3cd,stroke:#f57c00

Results: 70 software projects, 17 files each, ~$0.30 per project, 7 minutes.

Agent Orchestration Patterns

%%| echo: false
%%| fig-width: 12
flowchart LR
    A1[Agent A] --> A2[Agent B] --> A3[Agent C]
    
    T[Task] --> P1[Agent 1]
    T --> P2[Agent 2]
    T --> P3[Agent 3]
    P1 --> R[Results]
    P2 --> R
    P3 --> R
    
    S[Supervisor] --> H1[Worker 1]
    S --> H2[Worker 2]
    S --> H3[Worker 3]

Orchestration: Use Cases

The Risks of Agent Autonomy

Case Study: Replit Agent Failure

%%| echo: false
%%| fig-width: 10
flowchart LR
    U["User: Fix this bug"] --> A[Agent]
    A --> D1["Diagnoses: config file issue"]
    D1 --> D2["Decides: delete config"]
    D2 --> B["Bug in delete tool"]
    B --> C["Entire project wiped"]
    C --> X["Production DB destroyed"]
    
    style D1 fill:#fff3cd
    style D2 fill:#ffcccc
    style B fill:#ffcccc
    style X fill:#ff0000,color:#fff

Lesson: Agent autonomy requires multiple safety layers.

What went wrong:

Key principle: The more powerful the agent, the more guardrails it needs.

Agent Safety Challenges

%%| echo: false
%%| fig-width: 10
flowchart LR
    PI[Prompt Injection] --> A[Agent]
    AD[Adversarial Inputs] --> A
    GM[Goal Misalignment] --> A
    HA[Hallucinations] --> A
    CO[Capability Overhang] --> A
    LC[Lack of Corrigibility] --> A
    A --> H[Harm]
    
    style PI fill:#ffcccc
    style HA fill:#fff3cd
    style H fill:#ff0000,color:#fff

Autonomous agents amplify risks — a hallucination becomes action.

Agent Safety: Risk Taxonomy

Safety Mechanisms

%%| echo: false
%%| fig-width: 10
flowchart LR
    U[Input] --> IF[Input Filter]
    IF --> |Clean| A[Agent]
    IF --> |Malicious| B[Block]
    A --> OF[Output Filter]
    OF --> |Safe| R[Response]
    OF --> |Unsafe| B
    A --> M[Monitor]
    M --> |Anomaly| CB[Circuit Breaker]
    CB --> B
    
    style IF fill:#fff3e0,stroke:#f57c00
    style OF fill:#fff3e0,stroke:#f57c00
    style B fill:#ffcccc,stroke:#cc0000
    style R fill:#ccffcc,stroke:#00cc00
    style CB fill:#fce4ec,stroke:#c2185b

The Safety Pipeline:

• Input/Output Guards: Fast classifiers that run before and after the LLM.
• Monitoring: Watching for “strange” behavior (e.g., an agent trying to access a restricted database).
• Circuit Breakers: Automatically killing the agent process if safety thresholds are exceeded.

The Defense-in-Depth Pipeline

Key Principle: Never rely on the LLM to self-police. Use external code to enforce boundaries.

Human-in-the-Loop (HITL)

The most effective safety measure for high-stakes agents:

• Critical Actions: Require manual approval for destructive or financial operations (e.g., rm -rf, send_payment).
• Confirmation Dialogue: Show the agent’s proposed plan before execution.
• Feedback Loop: Allow the human to correct the agent’s reasoning.
• Audit Logs: Every action approved or rejected by a human is recorded for training and safety reviews.

Example: A code-refactoring agent proposes changes; a human developer reviews and clicks “Merge” or “Reject”.

Anthropic’s ASL-3 Safety Measures

For Claude Opus 4, Anthropic activated proactive safety:

%%| echo: false
%%| fig-width: 10
flowchart LR
    U[User] --> CC[Constitutional Classifiers]
    CC --> |Safe| M[Model]
    CC --> |Blocked| B[Reject]
    M --> OC[Output Check]
    OC --> |Safe| R[Response]
    OC --> |Harmful| B
    
    BB[Bug Bounty] --> CC
    RP[Rapid Patch] --> CC
    
    style CC fill:#c8e6c9,stroke:#2e7d32
    style B fill:#ffcccc,stroke:#cc0000
    style R fill:#e3f2fd,stroke:#1976d2

ASL-3: Safety Pipeline

Evaluating AI Agents

Traditional metrics (accuracy, precision) are insufficient for agents.

%%| echo: false
%%| fig-width: 10
flowchart LR
    TC["Task Completion"] --> Score["Overall Agent Score"]
    RQ["Reasoning Quality"] --> Score
    SA["Safety"] --> Score
    RE["Resource Efficiency"] --> Score
    ER["Error Recovery"] --> Score
    AD["Adversarial Robustness"] --> Score
    
    style SA fill:#ffcccc,stroke:#cc0000
    style Score fill:#c8e6c9,stroke:#2e7d32

Evaluation Approaches

%%| echo: false
%%| fig-width: 10
flowchart LR
    A[Agent Output] --> R[Rule-Based]
    A --> L[LLM-as-Judge]
    A --> H[Human Review]
    A --> S[Simulation]
    
    R --> E[Score]
    L --> E
    H --> E
    S --> E
    
    style R fill:#e3f2fd,stroke:#1976d2
    style L fill:#fff3e0,stroke:#f57c00
    style H fill:#c8e6c9,stroke:#2e7d32
    style S fill:#f3e5f5,stroke:#7b1fa2
    style E fill:#ffcccc,stroke:#cc0000

Best practice: Combine multiple approaches for comprehensive evaluation.

Domain-Specific Benchmarks

Agent capabilities are task-specific — benchmarks must match use cases.

Red-Teaming Agents

Systematic vulnerability testing:

%%| echo: false
%%| fig-width: 10
flowchart LR
    PI[Prompt Injection] --> A[Agent]
    ME[Agent Mistakes] --> A
    MU[Direct Misuse] --> A
    
    A --> |Vulnerability| V[Security Issue]
    A --> |Safe| S[Normal Operation]
    
    V --> R[Report]
    
    style PI fill:#ffcccc,stroke:#cc0000
    style ME fill:#fff3cd,stroke:#f57c00
    style MU fill:#ffcccc,stroke:#cc0000
    style V fill:#ffcccc,stroke:#cc0000
    style S fill:#ccffcc,stroke:#00cc00

Example: Hidden text in a webpage hijacks agent to exfiltrate data.

Comprehensive red-teaming found 1,200+ vulnerabilities in one enterprise agent.

Embodied AI: Robots

Software agents operate in digital systems. Embodied agents must handle:

%%| echo: false
%%| fig-width: 12
flowchart LR
    C["Camera"] --> F["Fusion"]
    L["Lidar"] --> F
    T["Touch"] --> F
    F --> B["Robot Brain"]
    B --> M["Motors"]
    M --> E["Environment"]
    E --> |"Feedback"| C
    
    style F fill:#fff3e0,stroke:#f57c00
    style B fill:#e3f2fd,stroke:#1976d2
    style E fill:#c8e6c9,stroke:#388e3c

The sim-to-real gap: Robots trained in simulation often fail in reality.

The Evolution of Robotic Intelligence

%%| echo: false
%%| fig-width: 10
flowchart LR
    S[1960s Shakey] --> P[1980s-2000s Probabilistic]
    P --> F[2020s Foundation Models]
    
    style S fill:#e3f2fd,stroke:#1976d2
    style P fill:#fff3e0,stroke:#f57c00
    style F fill:#c8e6c9,stroke:#2e7d32

Robotics: Capability Eras

LLMs have catalyzed a new era: robots that understand language and adapt.

Google’s Robotic Transformer (RT-2)

A vision-language-action model that directly controls robots:

%%| echo: false
%%| fig-width: 10
flowchart LR
    V[Vision Input] --> VLA[RT-2 Model]
    L[Language Input] --> VLA
    VLA --> A[Action Output]
    A --> R[Robot]
    R -- Feedback --> V
    
    style V fill:#e3f2fd,stroke:#1976d2
    style L fill:#fff3e0,stroke:#f57c00
    style VLA fill:#f3e5f5,stroke:#7b1fa2
    style A fill:#c8e6c9,stroke:#2e7d32
    style R fill:#ffcccc,stroke:#cc0000

General → Interactive → Dexterous

Works across robot forms: arms, humanoids, mobile platforms.

Robot Safety: ASIMOV

Named after Asimov’s Laws of Robotics, this benchmark tests embodied AI safety:

Key challenge: Context matters — “Hand me that knife” is safe in a kitchen, dangerous in a conflict.

Business relevance: As robots enter warehouses, hospitals, and homes, safety benchmarks become legal and ethical requirements.

Summary: NLP

The shift from symbols to vectors enabled modern NLP.

Summary: LLMs

Scale + alignment = emergent reasoning capabilities.

Summary: AI Agents

Agents transform LLMs from conversationalists to autonomous workers.

The Executive Perspective

For AI leaders:

• NLP powers search, chatbots, document analysis
• LLMs enable natural language interfaces to business systems
• Agents can automate complex, multi-step workflows
• Safety must be built in from the start, not bolted on
• Evaluation requires domain-specific benchmarks and human oversight

The promise: augmenting human intelligence — agents handle routine tasks while humans provide judgment, creativity, and ethical oversight.

Supplemental Reading

Online Articles:

• Making the Most of AI and Machine Learning in Organizations — Stanford
• The State of AI in 2024 — McKinsey
• Generative AI’s Act Two — Sequoia Capital

From the Textbook:

• Chapter 24: Natural Language Processing
• Chapter 26: AI Agents

What is Cursor?

Cursor is an AI-powered code editor built on VS Code. It allows you to:

• Write code with AI assistance
• Ask questions about your code
• Generate code from natural language descriptions
• Debug and fix errors with AI help

For this course, we’ll use Cursor to build an AI agent without needing deep programming expertise.

Part 4: Install Required Packages

Our project needs a few Python libraries. Install them in Cursor’s terminal:

pip install pandas numpy scikit-learn

You should see output indicating successful installation.

If you get a “pip not found” error on Mac:

pip3 install pandas numpy scikit-learn

Part 7: Keyboard Shortcuts Reference

Part 3: Building the Regression Model

Step 3.1: Understanding the Model

We’re building a model that predicts log of sales volume based on:

• Price: Higher price → lower sales (negative relationship)
• Featured (feat): If the product is in the weekly ad circular (1 = yes, 0 = no)
• Brand: Different brands have different base sales levels
• Price × Brand interaction: Price sensitivity varies by brand

Step 3.2: Prepare the Data for Modeling

Add this code to prepare features for the model:

# ============================================
# PART 3: BUILD THE REGRESSION MODEL
# ============================================

print("\n" + "="*50)
print("Building the pricing model...")
print("="*50)

# Create dummy variables for brand (one-hot encoding)
# This converts 'brand' text into numbers the model can use
brand_dummies = pd.get_dummies(df['brand'], prefix='brand', drop_first=False)

# Create the feature matrix
# We include: price, feat, brand dummies, and price*brand interactions
X = pd.DataFrame({
    'price': df['price'],
    'feat': df['feat'],
    'brand_minute.maid': brand_dummies['brand_minute.maid'],
    'brand_tropicana': brand_dummies['brand_tropicana'],
    # Interaction terms: price effect varies by brand
    'price_x_minute.maid': df['price'] * brand_dummies['brand_minute.maid'],
    'price_x_tropicana': df['price'] * brand_dummies['brand_tropicana']
})

# Target variable: log of sales (logmove)
y = df['logmove']

print(f"Features: {list(X.columns)}")
print(f"Target: logmove (log of sales volume)")

Step 3.3: Fit the Model

Add code to train the regression model:

# Fit the linear regression model
model = LinearRegression()
model.fit(X, y)

# Display the coefficients
print("\nModel Coefficients:")
print("-" * 40)
for feature, coef in zip(X.columns, model.coef_):
    print(f"  {feature}: {coef:.4f}")
print(f"  intercept: {model.intercept_:.4f}")

# Calculate R-squared (how well the model fits)
r_squared = model.score(X, y)
print(f"\nModel R-squared: {r_squared:.3f}")
print("(This means the model explains {:.1f}% of sales variation)".format(r_squared * 100))

Step 3.4: Run and Verify the Model

Save and run the script again. You should see coefficients like:

• price: negative (higher price = lower sales)
• feat: positive (being featured increases sales)
• brand coefficients: capture baseline differences between brands
• interaction terms: show how price sensitivity differs by brand

Part 4: Creating Helper Functions for the Agent

Step 4.1: Add Prediction Functions

Add these functions that the agent will use to answer questions:

# ============================================
# PART 4: HELPER FUNCTIONS FOR THE AGENT
# ============================================

def predict_sales(brand, price, featured=0):
    """
    Predict sales volume for a given brand, price, and feature status.
    
    Args:
        brand: 'tropicana', 'minute.maid', or 'dominicks'
        price: price in dollars (e.g., 2.50)
        featured: 1 if in ad circular, 0 if not
    
    Returns:
        Predicted sales volume (not log-transformed)
    """
    # Create feature vector
    features = {
        'price': price,
        'feat': featured,
        'brand_minute.maid': 1 if brand.lower() == 'minute.maid' else 0,
        'brand_tropicana': 1 if brand.lower() == 'tropicana' else 0,
        'price_x_minute.maid': price if brand.lower() == 'minute.maid' else 0,
        'price_x_tropicana': price if brand.lower() == 'tropicana' else 0
    }
    
    # Convert to dataframe for prediction
    X_pred = pd.DataFrame([features])
    
    # Predict log sales, then convert back
    log_sales = model.predict(X_pred)[0]
    sales = np.exp(log_sales)
    
    return sales


def get_price_elasticity(brand):
    """
    Calculate the price elasticity for a given brand.
    
    Price elasticity tells us: if price increases by 1%, 
    how much does quantity demanded change (in %)?
    
    A more negative number means more price-sensitive.
    """
    # Base price coefficient
    base_coef = model.coef_[0]  # price coefficient
    
    # Add brand-specific interaction if applicable
    if brand.lower() == 'minute.maid':
        interaction_coef = model.coef_[4]  # price_x_minute.maid
    elif brand.lower() == 'tropicana':
        interaction_coef = model.coef_[5]  # price_x_tropicana
    else:  # dominicks (base case)
        interaction_coef = 0
    
    total_elasticity = base_coef + interaction_coef
    return total_elasticity


def get_advertising_lift(brand):
    """
    Calculate the sales lift from being featured in advertising.
    Returns the percentage increase in sales.
    """
    # The 'feat' coefficient tells us the log-sales increase
    feat_coef = model.coef_[1]  # feat coefficient
    
    # Convert from log to percentage change
    percentage_lift = (np.exp(feat_coef) - 1) * 100
    return percentage_lift


def find_optimal_price(brand, min_price=1.0, max_price=4.0, featured=0):
    """
    Find the price that maximizes revenue for a brand.
    Revenue = Price × Quantity
    """
    best_price = min_price
    best_revenue = 0
    
    # Search through price range
    for price in np.arange(min_price, max_price, 0.05):
        sales = predict_sales(brand, price, featured)
        revenue = price * sales
        
        if revenue > best_revenue:
            best_revenue = revenue
            best_price = price
    
    return best_price, best_revenue


def compare_elasticities():
    """
    Compare price elasticity across all three brands.
    """
    brands = ['dominicks', 'minute.maid', 'tropicana']
    results = {}
    
    for brand in brands:
        elasticity = get_price_elasticity(brand)
        results[brand] = elasticity
    
    return results

Step 4.2: Test the Helper Functions

Add test code to verify the functions work:

# ============================================
# TEST THE HELPER FUNCTIONS
# ============================================

print("\n" + "="*50)
print("Testing helper functions...")
print("="*50)

# Test prediction
test_sales = predict_sales('tropicana', 2.50, featured=0)
print(f"\nPredicted sales for Tropicana at $2.50 (no ad): {test_sales:.0f} units")

# Test elasticity
elasticities = compare_elasticities()
print("\nPrice Elasticities by Brand:")
for brand, elast in elasticities.items():
    print(f"  {brand}: {elast:.3f}")

# Test advertising lift
lift = get_advertising_lift('minute.maid')
print(f"\nAdvertising lift: {lift:.1f}% increase in sales")

# Test optimal price
opt_price, opt_rev = find_optimal_price('dominicks')
print(f"\nOptimal price for Dominick's: ${opt_price:.2f} (revenue: ${opt_rev:.2f})")

Run the script again to verify all functions work correctly.

Part 5: Creating the AI Agent

Step 5.1: Add the Agent Logic

Now we’ll create the agent that interprets natural language questions and calls the appropriate functions. Add this code:

# ============================================
# PART 5: THE AI AGENT
# ============================================

def answer_question(question):
    """
    Simple agent that answers business questions about OJ pricing.
    
    This is a rule-based agent that matches keywords in the question
    to determine which analysis to perform.
    """
    question_lower = question.lower()
    
    # Question 1: Predict sales for specific scenario
    if 'predict' in question_lower or 'sales volume' in question_lower:
        # Extract brand and price from question if possible
        if 'tropicana' in question_lower:
            brand = 'tropicana'
        elif 'minute maid' in question_lower:
            brand = 'minute.maid'
        else:
            brand = 'dominicks'
        
        # Look for price (default to $2.50 if not found)
        import re
        price_match = re.search(r'\$?(\d+\.?\d*)', question_lower)
        price = float(price_match.group(1)) if price_match else 2.50
        
        # Check for advertising
        featured = 1 if 'advertis' in question_lower or 'feature' in question_lower else 0
        if 'no advertis' in question_lower or 'without advertis' in question_lower:
            featured = 0
        
        sales = predict_sales(brand, price, featured)
        
        response = f"""
**Predicted Sales Analysis**

Brand: {brand.title().replace('.', ' ')}
Price: ${price:.2f}
Featured in Ad: {'Yes' if featured else 'No'}

**Predicted Sales Volume: {sales:,.0f} units**

This prediction is based on our regression model that accounts for:
- Base demand for this brand
- Price sensitivity (elasticity)  
- Advertising effects
"""
        return response
    
    # Question 2: Which brand is most price-sensitive?
    elif 'price-sensitive' in question_lower or 'price sensitive' in question_lower or 'most sensitive' in question_lower:
        elasticities = compare_elasticities()
        
        # Find most price-sensitive (most negative elasticity)
        most_sensitive = min(elasticities, key=elasticities.get)
        
        response = f"""
**Price Sensitivity Analysis**

Price Elasticity by Brand:
"""
        for brand, elast in sorted(elasticities.items(), key=lambda x: x[1]):
            sensitivity = "HIGH" if elast < -3 else "MEDIUM" if elast < -2 else "LOW"
            response += f"- {brand.title().replace('.', ' ')}: {elast:.3f} ({sensitivity} sensitivity)\n"
        
        response += f"""
**Most Price-Sensitive: {most_sensitive.title().replace('.', ' ')}**

Interpretation: A 1% price increase leads to a {abs(elasticities[most_sensitive]):.1f}% decrease in sales for {most_sensitive.title().replace('.', ' ')}.

Business Implication: Be careful with price increases on {most_sensitive.title().replace('.', ' ')} - customers are very responsive to price changes.
"""
        return response
    
    # Question 3: Should we feature a brand in advertising?
    elif 'feature' in question_lower or 'ad circular' in question_lower or 'advertising' in question_lower:
        if 'minute maid' in question_lower:
            brand = 'minute.maid'
        elif 'tropicana' in question_lower:
            brand = 'tropicana'
        else:
            brand = 'dominicks'
        
        lift = get_advertising_lift(brand)
        
        # Calculate example impact
        base_sales = predict_sales(brand, 2.50, featured=0)
        featured_sales = predict_sales(brand, 2.50, featured=1)
        
        response = f"""
**Advertising Impact Analysis for {brand.title().replace('.', ' ')}**

Expected Sales Lift from Featuring: **{lift:.1f}%**

Example at $2.50:
- Without advertising: {base_sales:,.0f} units
- With advertising: {featured_sales:,.0f} units  
- Additional sales: {featured_sales - base_sales:,.0f} units

**Recommendation:** {'Yes, feature this product!' if lift > 20 else 'Consider the advertising cost vs. the sales lift.'}

The advertising effect is consistent across price points. Factor in your advertising costs to determine if the sales lift justifies the expense.
"""
        return response
    
    # Question 4: Optimal price for a brand
    elif 'optimal price' in question_lower or 'maximize revenue' in question_lower or 'best price' in question_lower:
        if 'minute maid' in question_lower:
            brand = 'minute.maid'
        elif 'tropicana' in question_lower:
            brand = 'tropicana'
        else:
            brand = 'dominicks'
        
        opt_price, opt_revenue = find_optimal_price(brand)
        opt_sales = predict_sales(brand, opt_price, featured=0)
        
        # Compare with current average price
        avg_price = df[df['brand'] == brand]['price'].mean()
        avg_revenue = avg_price * predict_sales(brand, avg_price, featured=0)
        
        response = f"""
**Revenue Optimization for {brand.title().replace('.', ' ')}**

**Optimal Price: ${opt_price:.2f}**

At optimal price:
- Predicted sales: {opt_sales:,.0f} units
- Revenue per store-week: ${opt_revenue:,.2f}

Comparison with current average (${avg_price:.2f}):
- Current revenue: ${avg_revenue:,.2f}
- Potential improvement: ${opt_revenue - avg_revenue:,.2f} ({((opt_revenue/avg_revenue)-1)*100:.1f}%)

Note: This optimization assumes no competitor response and stable market conditions.
"""
        return response
    
    # Question 5: Compare elasticities across brands
    elif 'compare' in question_lower or 'elasticity' in question_lower or 'across' in question_lower:
        elasticities = compare_elasticities()
        
        response = """
**Price Elasticity Comparison Across Brands**

| Brand | Elasticity | Interpretation |
|-------|------------|----------------|
"""
        for brand, elast in sorted(elasticities.items(), key=lambda x: x[1]):
            interp = f"1% price ↑ → {abs(elast):.1f}% sales ↓"
            response += f"| {brand.title().replace('.', ' ')} | {elast:.3f} | {interp} |\n"
        
        response += """
**Key Insights:**

1. **Dominick's** (store brand) is least price-sensitive - customers buying store brands may prioritize value and be less responsive to small price changes.

2. **Tropicana** shows moderate price sensitivity - as a premium brand, some customers are loyal but others will switch if prices rise.

3. **Minute Maid** is most price-sensitive - positioned between store and premium brands, these customers actively compare prices.

**Strategic Implications:**
- Use competitive pricing on Minute Maid to capture price-sensitive shoppers
- Tropicana can sustain moderate price premiums
- Dominick's margins can be optimized with less risk of volume loss
"""
        return response
    
    else:
        return """
I can help you with these types of questions:

1. **Sales Prediction:** "What is the predicted sales volume if we price Tropicana at $2.50?"
2. **Price Sensitivity:** "Which brand is most price-sensitive?"
3. **Advertising Impact:** "Should we feature Minute Maid in the ad circular?"
4. **Price Optimization:** "What price should we set for Dominick's to maximize revenue?"
5. **Elasticity Comparison:** "Compare the price elasticity across brands"

Please try one of these questions!
"""

Step 5.2: Add the Interactive Interface

Finally, add code to let users interact with the agent:

# ============================================
# PART 6: INTERACTIVE AGENT INTERFACE
# ============================================

def run_agent():
    """
    Run the interactive agent interface.
    """
    print("\n" + "="*60)
    print("🍊 ORANGE JUICE PRICING ANALYTICS AGENT 🍊")
    print("="*60)
    print("\nHello! I'm your pricing analytics assistant.")
    print("I can help you analyze orange juice pricing and promotions.")
    print("\nTry asking me questions like:")
    print("  - What is the predicted sales if we price Tropicana at $2.50?")
    print("  - Which brand is most price-sensitive?")
    print("  - Should we feature Minute Maid in the ad circular?")
    print("  - What price maximizes revenue for Dominick's?")
    print("  - Compare price elasticity across brands")
    print("\nType 'quit' to exit.\n")
    
    while True:
        question = input("Your question: ").strip()
        
        if question.lower() in ['quit', 'exit', 'q']:
            print("\nThank you for using the OJ Pricing Agent. Goodbye!")
            break
        
        if not question:
            continue
        
        print("\n" + "-"*50)
        response = answer_question(question)
        print(response)
        print("-"*50 + "\n")


# ============================================
# MAIN: RUN THE AGENT
# ============================================

if __name__ == "__main__":
    # Run the interactive agent
    run_agent()

Part 7: Writing Your Summary

Create a 1-page document (Word or PDF) that includes:

Section 1: Key Findings (half page)

• Which brand is most/least price-sensitive and why this matters
• The impact of advertising on sales
• The optimal pricing recommendations

Section 2: Surprises and Insights (quarter page)

• What surprised you about the results?
• How do these findings compare to your intuition?

Section 3: Business Implications (quarter page)

• How would you recommend a retailer use these insights?
• What additional data would make this analysis more useful?

Troubleshooting

“ModuleNotFoundError: No module named ‘pandas’”

Run: pip install pandas numpy scikit-learn

“FileNotFoundError: oj_data.csv”

Make sure the data file is in the same folder as your Python script.

“Model coefficients look wrong”

Check that your data loaded correctly - you should have ~28,000 rows.

“Agent doesn’t understand my question”

Try rephrasing using keywords like “predict”, “price-sensitive”, “feature”, “optimal”, or “compare”.

Complete Code Reference

The complete oj_agent.py file should be approximately 350-400 lines. If you get stuck, ask Cursor’s AI assistant for help by selecting your code and pressing Cmd+K (Mac) or Ctrl+K (Windows), then describing your issue. I also prepared a complete code reference for you to refer.

Case Study: Mudslide Threat

I live in a house at risk of a mudslide damage.

• Option A: Build a protective wall ($10,000).
• Damage Cost: $100,000 if the house is hit (and wall fails/absent).
• Wall Effectiveness: 95% protection.
• Probability of Mudslide: \(P(\text{Slide}) = 0.01\).

What is the best course of action?

Decision Tree: Initial Options

graph LR
    Start((Decision)) --> Build[Build Wall]
    Start --> NoBuild[Don't Build]
    
    Build -- "$10,000" --> WallNode{Slide?}
    WallNode -- "0.01" --> FailNode{Wall Fails?}
    FailNode -- "0.05" --> Loss["$100,000 Cost"]
    FailNode -- "0.95" --> NoLoss["$0 Cost"]
    WallNode -- "0.99" --> NoSlide["$0 Cost"]
    
    NoBuild -- "$0" --> SlideNode{Slide?}
    SlideNode -- "0.01" --> Loss2["$100,000 Cost"]
    SlideNode -- "0.99" --> NoLoss2["$0 Cost"]

Comparison: No Test

Don’t Build

\(EV = 0.01 \times \$100,000 = \$1,000\)

Build (No Test)

\(EV = \$10,000 + (0.01 \times 0.05 \times \$100,000) = \$10,050\)

[!IMPORTANT] Based purely on expected cost, Don’t Build is the rational choice despite the high impact of a slide.

The Geological Test

A test is available to better estimate the risk.

• Cost: $3,000
• Accuracy:
  • \(P( T \mid \text{Slide} ) = 0.90\)
  • \(P( \text{not } T \mid \text{No Slide} ) = 0.85\)

Should we take the test?

Updating Probabilities: Bayes’ Rule

Probability of Positive Test \(P(T)\):

\(P(T) = (0.90 \times 0.01) + (0.15 \times 0.99) = 0.1575\)

Posterior \(P(\text{Slide} \mid T)\):

\(P(\text{Slide} \mid T) = \frac{0.90 \times 0.01}{0.1575} \approx 0.0571\)

Posterior \(P(\text{Slide} \mid \text{not } T)\):

\(P(\text{Slide} \mid \text{not } T) = \frac{0.1 \times 0.01}{0.8425} \approx 0.0012\)

Risk vs. Reward

Conclusion

• Lowest Expected Cost: Don’t Build ($1,000).
• Lowest Risk of Catastrophe: Build without testing (0.0005).
• Middle Ground: Testing ($4,693) significantly reduces risk compared to “Don’t Build” without the full $10k upfront cost.

Decision? It depends on your utility function (risk tolerance).

View Python Implementation (Notebook)

Saint Petersburg Paradox

Imagine a gambling game where a fair coin is flipped repeatedly until it lands on heads. The payoff for the game is \(2^N\), where \(N\) is the number of tosses needed for the coin to land on heads.

The expected value of this game is infinite:

\[ E(X) = \frac{1}{2} \cdot 2 + \frac{1}{4} \cdot 4 + \frac{1}{8} \cdot 8 + \ldots = \infty \]

This means that, in theory, a rational person should be willing to pay any finite amount to play this game. However, in reality, most people would be unwilling to pay a large amount.

Expected Utility Resolution

Bernoulli argued that people do not maximize expected monetary value but rather expected utility \(U(x)\).

\[ E[U(X)] = \sum^\infty_{k=1} 2^{-k} U(2^k) \]

For the log utility case, \(U(x) = \log(x)\), the expected utility is \(2 \log(2)\). To find the certain dollar amount \(x^*\) (certainty equivalent) that provides the same utility:

\[ \log(x^*) = 2\log(2) = \log(2^2) = \log(4) \implies x^* = 4 \]

Under log utility, a rational player would pay at most $4 to play, despite the infinite expected monetary value.

Online: 2 Weeks (14 Days)

Email: vsokolov@gmu.edu

Phone: 703 993 4533

Course Textbook: Bayes, AI and Deep Learning by Nick Polson and Vadim Sokolov. The book is to be published by Chapman & Hall/CRC in 2026. Available for free online.

Topic Purpose

The purpose of this topic is to introduce participants to the foundational concepts of artificial intelligence and data-driven decision making. Participants will develop a working understanding of probability, statistical modeling, and modern AI techniques—equipping them to lead AI initiatives, evaluate AI investments, and communicate effectively with technical teams.

Topic Overview

This module takes executives on a journey from the fundamentals of probability and uncertainty through statistical modeling to the cutting edge of modern AI. Rather than focusing on mathematical derivations, we emphasize intuition, real-world applications, and business implications. Through compelling case studies—from wrongful convictions caused by probability errors to the Netflix Prize’s lessons about model complexity—participants will learn to think probabilistically about business decisions. The module culminates in a hands-on project where participants build an AI agent using Cursor IDE, directly experiencing how data, models, and AI agents work together to solve business problems.

Topic Objectives

Upon completion of this topic, you should understand and be able to:

• Apply probabilistic thinking to business decisions under uncertainty
• Recognize common probability fallacies (prosecutor’s fallacy, base rate neglect) and their business implications
• Understand the trade-offs between model accuracy, complexity, and business value
• Interpret regression models and explain their predictions to stakeholders
• Evaluate when AI/ML solutions are appropriate versus traditional statistical approaches
• Build a simple AI agent that combines data analysis with natural language interaction
• Lead informed conversations with data science and AI teams

Course Approach

This topic combines asynchronous learning (recorded lectures, readings, discussion boards) with synchronous sessions (live Zoom calls) and hands-on practice. The approach emphasizes:

• Case-based learning: Each concept is grounded in real-world examples—from legal cases to sports analytics to retail pricing
• Business-first perspective: Technical concepts are always connected to business decisions and outcomes
• Progressive building: Each module builds on the previous, culminating in an integrated final project
• Peer learning: Discussion boards encourage sharing experiences and learning from diverse industry perspectives
• Applied practice: The final project provides hands-on experience building an AI-powered analytics tool

Time Commitment

This topic will require approximately 10 hours of work to complete:

Schedule